﻿using System.Globalization;
using System.Text.RegularExpressions;

namespace Service.Framework.Utils
{
    public static class DateTimeUtil
    {
        //
        // 摘要:
        //     DateTime
        //
        // 参数:
        //   value:
        //
        // 类型参数:
        //   T:
        public static DateTime ToDateTime<T>(this T value)
        {
            if (value == null)
            {
                return DateTime.MinValue;
            }

            DateTime result;
            return DateTime.TryParse(value.ToStr(), out result) ? result : DateTime.MinValue;
        }

        //
        // 摘要:
        //     DateTime?
        //
        // 参数:
        //   value:
        //
        // 类型参数:
        //   T:
        public static DateTime? ToDateTimeNull<T>(this T value)
        {
            if (value == null)
            {
                return null;
            }

            DateTime result;
            return DateTime.TryParse(value.ToStr(), out result) ? new DateTime?(result) : null;
        }

        //
        // 摘要:
        //     格式的 时间 字符串
        //
        // 参数:
        //   value:
        //
        //   formatStr:
        //
        // 类型参数:
        //   T:
        public static string ToDateTimeFormat<T>(this T value, string formatStr = "yyyy-MM-dd")
        {
            DateTime dateTime = value.ToDateTime();
            return (dateTime.ToShortDateString() == DateTime.MinValue.ToShortDateString()) ? string.Empty : dateTime.ToString(formatStr);
        }

        //
        // 摘要:
        //     将字符串日期 转化为 日期类型
        //
        // 参数:
        //   value:
        public static DateTime ToDateTimeByString(this string value)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    return DateTime.MinValue;
                }

                if (value.Contains('-') || value.Contains('/'))
                {
                    return DateTime.Parse(value);
                }

                int length = value.Length;
                if (1 == 0)
                {
                }

                DateTime result = length switch
                {
                    4 => DateTime.ParseExact(value, "yyyy", CultureInfo.CurrentCulture),
                    6 => DateTime.ParseExact(value, "yyyyMM", CultureInfo.CurrentCulture),
                    8 => DateTime.ParseExact(value, "yyyyMMdd", CultureInfo.CurrentCulture),
                    10 => DateTime.ParseExact(value, "yyyyMMddHH", CultureInfo.CurrentCulture),
                    12 => DateTime.ParseExact(value, "yyyyMMddHHmm", CultureInfo.CurrentCulture),
                    14 => DateTime.ParseExact(value, "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
                    _ => DateTime.ParseExact(value, "yyyyMMddHHmmss", CultureInfo.CurrentCulture),
                };
                if (1 == 0)
                {
                }

                return result;
            }
            catch
            {
                return DateTime.MinValue;
            }
        }

        //
        // 摘要:
        //     判断字符串是否为时间戳
        //
        //     注意 : 默认 仅限于 2000年之后 到当前时间 的时间戳
        //
        // 参数:
        //   timestampString:
        //
        //   startTime:
        //
        //   endTime:
        public static bool IsTimestampString(string timestampString, DateTime? startTime = null, DateTime? endTime = null)
        {
            if (string.IsNullOrWhiteSpace(timestampString))
            {
                return false;
            }

            if (!Regex.IsMatch(timestampString, "^[0-9]*$"))
            {
                return false;
            }

            if (!long.TryParse(timestampString, out var result))
            {
                return false;
            }

            if (result < 1)
            {
                return false;
            }

            if (result > DateTimeOffset.MaxValue.ToUnixTimeSeconds())
            {
                return false;
            }

            if (result < DateTimeOffset.MinValue.ToUnixTimeSeconds())
            {
                return false;
            }

            if (!startTime.HasValue)
            {
                startTime = new DateTime(2000, 1, 1);
            }

            if (!endTime.HasValue)
            {
                endTime = DateTime.Now.AddDays(1.0);
            }

            if (startTime.HasValue && endTime.HasValue)
            {
                long num = startTime.Value.ToUnixTimeSeconds();
                long num2 = endTime.Value.ToUnixTimeSeconds();
                if (result < num || result > num2)
                {
                    return false;
                }
            }

            string value = result.ToLocalDateTimeString();
            DateTime dateTime = value.ToDateTimeByString();
            DateTime value2 = dateTime;
            DateTime? dateTime2 = startTime;
            int result2;
            if (value2 > dateTime2)
            {
                value2 = dateTime;
                dateTime2 = endTime;
                result2 = ((value2 <= dateTime2) ? 1 : 0);
            }
            else
            {
                result2 = 0;
            }

            return (byte)result2 != 0;
        }

        //
        // 摘要:
        //     转时间戳
        //
        // 参数:
        //   dateTime:
        public static long ToUnixTimeSeconds(this DateTime dateTime)
        {
            return ((DateTimeOffset)dateTime).ToUnixTimeSeconds();
        }

        //
        // 摘要:
        //     时间戳转换为 utc
        //
        // 参数:
        //   timeStamp:
        public static DateTime ToUtcDateTime(this long timeStamp)
        {
            return DateTimeOffset.FromUnixTimeSeconds(timeStamp).UtcDateTime;
        }

        //
        // 摘要:
        //     时间戳转换为 local 时间
        //
        // 参数:
        //   timeStamp:
        public static DateTime ToLocalDateTime(this long timeStamp)
        {
            return DateTimeOffset.FromUnixTimeSeconds(timeStamp).LocalDateTime;
        }

        //
        // 摘要:
        //     时间戳(毫秒)转换为 utc
        //
        // 参数:
        //   timeStamp:
        public static DateTime ToUtcDateTimeMs(this long timeStamp)
        {
            return DateTimeOffset.FromUnixTimeMilliseconds(timeStamp).UtcDateTime;
        }

        //
        // 摘要:
        //     时间戳(毫秒)转换为 local 时间
        //
        // 参数:
        //   timeStamp:
        public static DateTime ToLocalDateTimeMs(this long timeStamp)
        {
            return DateTimeOffset.FromUnixTimeMilliseconds(timeStamp).LocalDateTime;
        }

        //
        // 摘要:
        //     时间戳转换为本地时间
        //
        // 参数:
        //   timeStamp:
        public static string ToLocalDateTimeString(this long timeStamp)
        {
            DateTime dateTime = timeStamp.ToLocalDateTime();
            if (dateTime == DateTime.MinValue)
            {
                return string.Empty;
            }

            return dateTime.ToString("yyyy-MM-dd HH:mm:ss");
        }

        //
        // 摘要:
        //     判断字符串是否为有效的 日期类型
        //
        // 参数:
        //   input:
        public static bool IsDateTimeByString(string? input)
        {
            if (string.IsNullOrWhiteSpace(input))
            {
                return false;
            }

            if (Regex.IsMatch(input, "^[0-9]*$"))
            {
                return false;
            }

            if (double.TryParse(input, out var result) && result > 0.0)
            {
                return false;
            }

            if (!input.Contains('-') && !input.Contains('/'))
            {
                return false;
            }

            DateTime dateTime = input.ToDateTimeByString();
            if (dateTime > DateTime.MinValue && dateTime < DateTime.MaxValue)
            {
                return true;
            }

            return false;
        }

        //
        // 摘要:
        //     转化 天 时 分 秒
        //
        // 参数:
        //   timeDifference:
        public static string ToDayHourMinutesSeconds(this TimeSpan timeDifference)
        {
            int days = timeDifference.Days;
            int hours = timeDifference.Hours;
            int minutes = timeDifference.Minutes;
            int seconds = timeDifference.Seconds;
            return $"{days}天{hours}小时{minutes}分钟{seconds}秒";
        }

        //
        // 摘要:
        //     时间戳转为C#格式时间
        //
        // 参数:
        //   timeStamp:
        //
        // 类型参数:
        //   T:
        public static DateTime ToTime<T>(this int timeStamp)
        {
            DateTime dateTime = TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1), TimeZoneInfo.Local);
            long ticks = long.Parse(timeStamp + "0000000");
            TimeSpan value = new TimeSpan(ticks);
            return dateTime.Add(value);
        }

        //
        // 摘要:
        //     DateTime时间格式转换为Unix时间戳格式
        //
        // 参数:
        //   time:
        //
        // 类型参数:
        //   T:
        public static int ToTimeInt<T>(this DateTime time)
        {
            DateTime dateTime = TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1), TimeZoneInfo.Local);
            return (int)(time - dateTime).TotalSeconds;
        }
    }
}
